import random
import string
import 实验4
import telnetlib
from IPy import IP
import  collections
"""#测试IP是否可用
ip=IP('192.168.0.0/24')
list=[]
for i in ip:
   list.append(i)
with open("测试ip","w+") as f:
 for i in list:
  try:
      telnetlib.Telnet(i,port='80', timeout=20)
  except:
    print(f"{i} 已经被使用")
    f.write(f"{i} 已经被使用\n")
  else:
    print(f"{i} 可用！！！")
    f.write(f"{i} 可用\n")
"""
"""#作业1密码验证
result = []

def tlength(pw):
    if (len(pw) > 8):
        return 1
    return 0

def tmix(pw):
    n = 0
    f = {"bw": 0, "lw": 0, "n": 0, "o1": 0, "o2": 0}
    for i in pw:
        if i in string.ascii_uppercase:
            f["bw"] = 1
        elif i in string.ascii_lowercase:
            f["lw"] = 1
        elif i in string.digits:
            f["n"] = 1
        elif i in string.punctuation:
            f["o1"] = 1
        else:
            f["o2"] = 1
    for i in f:
       n += f[i]
    if n >= 3:
        return 1
    return 0

def tc(pw):
    for i in range(len(pw)):
        for j in range(i + 3, len(pw)):
            t = pw[i:j]
            s = pw[j:len(pw)]
            if t in s:
                return 0
    return 1


def end(pw, num, result):
    if tlength(pw) == 0:
        result.append("密码长度等于或少于8位！")
        num += 0
    else:
        num += 1
    if tmix(pw) == 0:
        result.append("密码没有由3种或以上字符组成！")
        num += 0
    else:
        num += 1
    if tc(pw) == 0:
        result.append("密码有长度等于或超过3的子串重复！")
        num += 0
    else:
        num += 1
    return num


pw = input("请输入您的密码：")
num = 2
num = end(pw, num, result)
print(f"{num},{result}")
"""
"""#作业2列表去重，并从大到小排序
list1=random.choices(string.ascii_letters,k=30)
print(list1)
list2=[]
for i in  list1:
     if i not in list2:
         list2.append(i)
list2.sort(reverse=True)
print(list2)
"""
"""#作业3函数内部修改全局变量
i=1
def ab():
  global i
  i=2
ab()
print(i)
"""

"""#作业4跨模块共享全局变量
   要实现跨模块共享全局变量，一般会利用一个名为“config.py”的文件 在里面生成全局变量 i，
   如果要在b.py模块中引用此变量则直接importconfig.py然后即可在b.py中用config.i的方式对此变量进行引用， 
   若还需要在c.py模块中对此变量进行应用，如果想要保存在b.py中对此变量的修改需导入这个两个模块，负责只导入config.py即可
   在实验4.py中操作：
   import config
   config.i=2
   在5.py中引用此变量保存在b.py中的修改
   import config
   import 实验4
   print(config.i)
结果    
2
"""
"""#作业5python数据类型
1.数字类型 主要包括int（整型）、long（长整型）和float（浮点型）
2.字符串 在Python中，加了引号的字符都被认为是字符串，
  其声明有三种方式，分别是：单引号、双引号和三引号；
  Python中的字符串有两种数据类型，分别是str类型和unicode类型，
  str类型采用的ASCII编码，无法表示中文，
  unicode类型采用unicode编码，能够表示任意字符，包括中文和其他语言。
3.布尔型 和其他编程语言一样，Python布尔类型也是用于逻辑运算，有两个值：True（真）和False（假）
4. 列表 列表是Python中使用最频繁的数据类型，集合中可以放任何数据类型，可对集合进行创建、查找、切片、增加、修改、删除、循环和排序操作。
5. 元组 元组和列表一样，也是一种序列，与列表不同的是，元组是不可修改的，元组用”()”标识，内部元素用逗号隔开。
6. 字典 字典是一种键值对的集合，是除列表以外Python之中最灵活的内置数据结构类型，列表是有序的对象集合，字典是无序的对象集合。
7. 集合 集合是一个无序的、不重复的数据组合，它的主要作用有两个，分别是去重和关系测试。
"""
"""#作业6python中生成随机
i=random.randint(1,10)
j=random.uniform(1,10)
y=random.random()

print(i)
print(j)
print(y)
"""
"""#作业7python2和3的区别
1.print 从语句变为函数 
Python3中print为一个函数，必须用括号括起来；Python2中print为class ,不需要用括号。
2.原 : range( 0, 4 )   结果 是 列表 [0,1,2,3 ]
改为：list( range(0,4) )
原 : xrange( 0, 4 )    适用于 for 循环的变量控制
改为：range(0,4)
3.通过input()解析用户的输入：（Python3中input得到的为str；Python2的input的到的为int型，
Python2的raw_input得到的为str类型）统一一下：Python3中用input，Python2中用row_input，都输入为str
4.python2数据类型中有长整型，python3中没有。
5.Python3中/表示真除，%表示取余，//结果取整；
  Python2中带上小数点/表示真除，%表示取余，//结果取整
"""
"""#8、python中哪些是可变数据类型，哪些是不可变数据类型，为什么
   可变数据类型：列表list和字典dict；不可变数据类型：整型int、浮点型float、字符串型string和元组tuple。
   python中的不可变数据类型，不允许变量的值发生变化，如果改变了变量的值，相当于是新建了一个对象，而对于相同的值的对象，
   在内存中则只有一个对象，内部会有一个引用计数来记录有多少个变量引用这个对象；可变数据类型，允许变量的值发生变化，
   即如果对变量进行append、+=等这种操作后，只是改变了变量的值，而不会新建一个对象，变量引用的对象的地址也不会变化，
   不过对于相同的值的不同对象，在内存中则会存在不同的对象，即每个对象都有自己的地址，相当于内存中对于同值的对象保存了多份，
   这里不存在引用计数，是实实在在的对象。
"""

"""#9、统计字符串中每个单词出现的次数

str=input("请输入字符串：")
a=input("请输入需要统计的单词：")
list=str.split(" ")
print(list.count(a))
"""

"""#作业10
给定一个字符串，找到字符串中第一个重复的字符
str=input("请输入字符串")
for i in range(len(str)-1):
    for j in range(i+1,len(str)):
        if str[i]==str[j]:
            print(str[i])
            quit()

"""
"""
#11什么是pep8
1 缩进。4个空格的缩进（编辑器都可以完成此功能），不使用Tap，更不能混合使用Tap和空格。

2 每行最大长度79，换行可以使用反斜杠，最好使用圆括号。换行点要在操作符的后边敲回车。

3 类和top-level函数定义之间空两行；类中的方法定义之间空一行；函数内逻辑无关段落之间空一行；其他地方尽量不要再空行。

4 模块导入的顺序：按标准、三方和自己编写顺序依次导入，之间空一行。

5 不要在一句import中多个库，比如import os, sys不推荐

6避免不必要的空格

7 注释必须要有

8 函数命名要遵循规范

10 尽可能使用‘is’‘is not’取代‘==’，比如if x is not None 要优于if x。

11 使用基于类的异常，每个模块或包都有自己的异常类，此异常类继承自Exception。
12 异常中try的代码尽可能少。
"""
"""
12字典深浅拷贝的区别 
a={1:[1,2,3]} b=a.copy( ) b=a不是拷贝只是让b指向
 print(id(a),id(b))   a[2]='no.2' a[1].append(4)
 print(a) print(b) 结果 2222335 2222335    {1:[1,2,3,4],2:'no.2'} {1:[1,2,3,4],2:'no.2'} 
深拷贝 指向的不是同一对象 递归所有层的数据 而不是地址
  a={1:[1,2,3]} b=copy.deepcopy(a) print(id(a),id(b)) a[2]='no.2' a[1].append(4) 
  print(a) print(b) 13233355 1323346 {1:[1,2,3,4],2:'no.2'} {1:[1,2,3]}
总结
原字典与赋值
紧密相连；一方改变，对方随之改变！
原字典与浅拷贝
父级各自独立，子级紧密相连；一方改变，对方父级不变，子级随之改变！
原字典与深拷贝
深拷贝独立门户，从此与原字典无关.
"""
 


"""
13内存管理机制
1引用计数动态类型
每一个对象（对象是存储在内存的实体）都会维护一个引用计数，有引用指向该对象就加1
没有就为0，del（a）删除a变量的引用 
查看引用计数 首先form sys import getrefcount 
sys.getrefcount(对象名)可以查看引用计数（返回值是在真实引用上加1，因为此处查看也引用了对象）
2垃圾回收机制 
 分代（generation）回收
python将所有的对象分为0，1，2三代 所有的新建对象就是0代对象。
当某一对对象经过垃圾回收，依然存活，那么它就被归入为下一代对象，
存活时间越久的对象，越不可能在后面的程序中变成垃圾。
  标记清除
    首先标记对象（垃圾检测），然后清除垃圾 （垃圾回收）
    标记：活动（有被引用）非活动（可被删除）
    清除 清除所有的非活动的对象。
    主要用于解决循环引用。
3缓冲池机制
    python对于短小的，只含有字母数字的字符串会自动触发缓存机制，
    其他的情况不会缓存。（-5到256里面的小整数对象 缓冲区里卖弄自动开辟地址）
    字符串没有缓冲区，有驻留区（有特殊字符不会创建到里面）单个特殊字符在。
    会先去找驻留区找，没有再创建。
"""
"""
 作业14python冒泡
list=[]
num=int(input("您需要排序多少个数："))
for i in range(num):
      num1=int(input(f"请输入第{i+1}个数"))
      list.append(num1)                  #将输入的数添加到列表
print("原列表为:")
print(list)
for s in range(len(list)-1):
    for j in range(0,(len(list)-s-1)):
         if list[j] >list[j+1]:
              list[j],list[j+1]=list[j+1],list[j]
print(list)
"""
"""
#15python快排
import random
def quicksort(lists,i,j):
        if i >= j:                                  
            return lists                             
        pivot = lists[i]
        low = i
        high = j
        while i < j:
            while i < j and lists[j] >= pivot:
                j -= 1
            lists[i] = lists[j]
            while i < j and lists[i] <= pivot:
                i += 1
            lists[j] = lists[i]
        lists[j] = pivot
        quicksort(lists, low, i-1)
        quicksort(lists, i+1, high)
        return lists
num=int(input("您想要对多少数进行排序："))
list=[]
for i in range(num):
    num1=int(input(f"请输入要排序的第{i+1}的数"))
    list.append(num1)
print(f"排序前序列为:{list}")
print(f"排序后序列为:{quicksort(list,0,len(list)-1)}")



"""


"""
#作业16输出九九乘法表
for i in range(1,10):
    for j in range(1,i+1):
        num=i*j
        print(f"{i}*{j}={num}",end=" ")
    print("\n")
"""





"""
#作业17判断是否为正数：
while True:
    n=input("请输入正整数：")
    if n.isdigit() and int(n)>0 and not "." in n :
        print(f"输入正确！您输入的是:{n}")
        break
"""
"""
#作业18两列表排序
a=[11,-3,4,5,2,1,8]
b=[9,3,4,2,6,-10]
c=a+b
c.sort()
print(c)
"""